#include "wifi_manager.h"
#include "esp32_s3_szp.h"
#include <stdio.h>
#include <string.h>
#include "esp_log.h"
#include "esp_wifi.h"
#include "esp_event.h"
#include "esp_netif.h"
#include "nvs_flash.h"
#include "nvs.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "esp_http_server.h"
#include "lwip/sockets.h"
#include "lwip/netdb.h"
#include "esp_system.h"

static const char *TAG = "wifi_manager";

// 全局变量
static int s_retry_num = 0;
static httpd_handle_t config_server = NULL;
static wifi_work_mode_t current_wifi_mode = WIFI_MODE_CONFIG;
static bool wifi_connected = false;

// 全局变量用于跟踪连接状态
static bool connection_in_progress = false;
static char connecting_ssid[MAX_SSID_LENGTH] = {0};
static int connection_result = 0;  // 0=进行中, 1=成功, -1=失败
static char connected_ip[16] = {0};  // 保存连接成功后的IP地址

// 前向声明
static void event_handler(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data);
static void delayed_restart_task(void *pvParameters);
static void deferred_sta_connect_task(void *pvParameters);
static int hex_to_int(char c);
static void url_decode(char* dst, const char* src, size_t max_len);
static void json_escape_string(char* dst, const char* src, size_t max_len);

// 延迟重启任务
static void delayed_restart_task(void *pvParameters)
{
    ESP_LOGI(TAG, "延迟重启任务启动，5秒后重启设备");
    vTaskDelay(5000 / portTICK_PERIOD_MS);
    ESP_LOGI(TAG, "WiFi配网完成，重启设备");
    esp_restart();
}

//=============================================================================
// NVS存储相关功能
//=============================================================================

// 保存WiFi配置到NVS
esp_err_t wifi_save_config(const char* ssid, const char* password)
{
    nvs_handle_t nvs_handle;
    esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "打开NVS失败: %s", esp_err_to_name(err));
        return err;
    }

    // 保存SSID（增加调试信息）
    ESP_LOGI(TAG, "准备保存SSID: %s (长度: %d字节)", ssid, strlen(ssid));
    err = nvs_set_str(nvs_handle, NVS_SSID_KEY, ssid);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "保存SSID失败: %s", esp_err_to_name(err));
        nvs_close(nvs_handle);
        return err;
    }

    // 保存密码（不记录具体密码内容，只记录长度）
    ESP_LOGI(TAG, "准备保存密码 (长度: %d字节)", strlen(password));
    err = nvs_set_str(nvs_handle, NVS_PASS_KEY, password);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "保存密码失败: %s", esp_err_to_name(err));
        nvs_close(nvs_handle);
        return err;
    }

    // 提交更改
    err = nvs_commit(nvs_handle);
    nvs_close(nvs_handle);
    
    if (err == ESP_OK) {
        ESP_LOGI(TAG, "WiFi配置已保存: %s", ssid);
    }

    return err;
}

// 从NVS加载WiFi配置
esp_err_t wifi_load_config(char* ssid, char* password)
{
    nvs_handle_t nvs_handle;
    esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READONLY, &nvs_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "打开NVS失败: %s", esp_err_to_name(err));
        return err;
    }

    size_t required_size;
    
    // 读取SSID
    required_size = MAX_SSID_LENGTH;
    err = nvs_get_str(nvs_handle, NVS_SSID_KEY, ssid, &required_size);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "读取SSID失败: %s", esp_err_to_name(err));
        nvs_close(nvs_handle);
        return err;
    }
    ESP_LOGI(TAG, "成功读取SSID: %s (长度: %d字节)", ssid, strlen(ssid));

    // 读取密码
    required_size = MAX_PASS_LENGTH;
    err = nvs_get_str(nvs_handle, NVS_PASS_KEY, password, &required_size);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "读取密码失败: %s", esp_err_to_name(err));
        nvs_close(nvs_handle);
        return err;
    }
    ESP_LOGI(TAG, "成功读取密码 (长度: %d字节)", strlen(password));

    nvs_close(nvs_handle);
    ESP_LOGI(TAG, "WiFi配置已加载: %s", ssid);
    return ESP_OK;
}

// 检查是否已配置WiFi
bool wifi_is_configured(void)
{
    char ssid[MAX_SSID_LENGTH];
    char password[MAX_PASS_LENGTH];
    esp_err_t err = wifi_load_config(ssid, password);
    
    // 改进：更好的验证逻辑，检查SSID是否为空或只包含空白字符
    if (err != ESP_OK) {
        ESP_LOGD(TAG, "加载WiFi配置失败: %s", esp_err_to_name(err));
        return false;
    }
    
    // 检查SSID是否有效（不为空且不只是空白字符）
    bool has_content = false;
    for (int i = 0; i < MAX_SSID_LENGTH && ssid[i] != '\0'; i++) {
        if (ssid[i] != ' ' && ssid[i] != '\t' && ssid[i] != '\n' && ssid[i] != '\r') {
            has_content = true;
            break;
        }
    }
    
    if (has_content) {
        ESP_LOGI(TAG, "发现有效的WiFi配置: %s", ssid);
    } else {
        ESP_LOGD(TAG, "WiFi配置为空或无效");
    }
    
    return has_content;
}

// 清除WiFi配置
esp_err_t wifi_clear_config(void)
{
    nvs_handle_t nvs_handle;
    esp_err_t err = nvs_open(NVS_NAMESPACE, NVS_READWRITE, &nvs_handle);
    if (err != ESP_OK) {
        ESP_LOGE(TAG, "打开NVS失败: %s", esp_err_to_name(err));
        return err;
    }

    // 删除SSID和密码
    nvs_erase_key(nvs_handle, NVS_SSID_KEY);
    nvs_erase_key(nvs_handle, NVS_PASS_KEY);
    
    // 提交更改
    err = nvs_commit(nvs_handle);
    nvs_close(nvs_handle);
    
    if (err == ESP_OK) {
        ESP_LOGI(TAG, "WiFi配置已清除");
    } else {
        ESP_LOGE(TAG, "清除WiFi配置失败: %s", esp_err_to_name(err));
    }
    
    return err;
}

//=============================================================================
// WiFi扫描相关功能
//=============================================================================

// 扫描周围的WiFi网络
esp_err_t wifi_scan_networks(wifi_ap_record_t* ap_records, uint16_t* ap_count)
{
    esp_err_t ret = ESP_OK;
    uint16_t max_aps = *ap_count;
    *ap_count = 0;

    // 检查WiFi模式
    wifi_mode_t mode;
    esp_wifi_get_mode(&mode);
    ESP_LOGI(TAG, "当前WiFi模式: %d", mode);
    
    // 确保WiFi处于可以扫描的模式（APSTA或STA）
    if (mode != WIFI_MODE_APSTA && mode != WIFI_MODE_STA) {
        ESP_LOGE(TAG, "WiFi模式不支持扫描，当前模式: %d", mode);
        return ESP_ERR_WIFI_MODE;
    }

    // 清除之前的扫描结果
    esp_wifi_scan_stop();
    vTaskDelay(100 / portTICK_PERIOD_MS);

    // 开始扫描
    wifi_scan_config_t scan_config = {
        .ssid = NULL,
        .bssid = NULL,
        .channel = 0,
        .show_hidden = true,  // 也显示隐藏网络
        .scan_type = WIFI_SCAN_TYPE_ACTIVE,
        .scan_time.active.min = 120,
        .scan_time.active.max = 500,
    };

    ESP_LOGI(TAG, "开始WiFi扫描...");
    ret = esp_wifi_scan_start(&scan_config, true);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "WiFi扫描启动失败: %s (0x%x)", esp_err_to_name(ret), ret);
        
        // 如果扫描失败，尝试重置WiFi状态
        if (ret == ESP_ERR_WIFI_STATE) {
            ESP_LOGW(TAG, "WiFi状态错误，尝试重新初始化扫描");
            esp_wifi_scan_stop();
            vTaskDelay(500 / portTICK_PERIOD_MS);
            ret = esp_wifi_scan_start(&scan_config, true);
            if (ret != ESP_OK) {
                ESP_LOGE(TAG, "重试扫描仍然失败: %s", esp_err_to_name(ret));
                return ret;
            }
        } else {
            return ret;
        }
    }
    
    // 获取扫描结果
    uint16_t ap_count_temp = max_aps;
    ret = esp_wifi_scan_get_ap_records(&ap_count_temp, ap_records);
    if (ret != ESP_OK) {
        ESP_LOGE(TAG, "获取扫描结果失败: %s", esp_err_to_name(ret));
        return ret;
    }
    
    *ap_count = ap_count_temp;

    ESP_LOGI(TAG, "WiFi扫描完成，发现%d个网络", *ap_count);
    
    // 打印找到的网络（调试用）
    for (int i = 0; i < *ap_count; i++) {
        ESP_LOGI(TAG, "发现网络 %d: %s, RSSI: %d, 加密: %d", 
                i, (char*)ap_records[i].ssid, ap_records[i].rssi, ap_records[i].authmode);
    }
    
    // 按信号强度排序
    for (int i = 0; i < *ap_count - 1; i++) {
        for (int j = 0; j < *ap_count - i - 1; j++) {
            if (ap_records[j].rssi < ap_records[j + 1].rssi) {
                wifi_ap_record_t temp = ap_records[j];
                ap_records[j] = ap_records[j + 1];
                ap_records[j + 1] = temp;
            }
        }
    }
    
    return ESP_OK;
}

//=============================================================================
// WiFi事件处理相关功能
//=============================================================================

// WiFi事件处理函数
static void event_handler(void* arg, esp_event_base_t event_base,
                                int32_t event_id, void* event_data)
{
    // STA模式事件处理
    if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_START) {
        ESP_LOGI(TAG, "WIFI_EVENT_STA_START 事件触发");
        if (current_wifi_mode == WIFI_MODE_CONNECTING) {
            // 避免在事件回调里直接连接，改为投递到任务，减少竞态
            xTaskCreate(deferred_sta_connect_task, "sta_connect", 3072, NULL, 4, NULL);
        }
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_STA_DISCONNECTED) {
        wifi_event_sta_disconnected_t* disconnected_event = (wifi_event_sta_disconnected_t*) event_data;
        wifi_connected = false;
        
        // 如果正在进行连接过程，根据断开原因判断是否为密码错误
        if (connection_in_progress) {
            ESP_LOGI(TAG, "WiFi断开连接，原因: %d", disconnected_event->reason);
            
            // 检查断开原因是否为认证失败（密码错误）
            if (disconnected_event->reason == WIFI_REASON_AUTH_FAIL || 
                disconnected_event->reason == WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT ||
                disconnected_event->reason == WIFI_REASON_HANDSHAKE_TIMEOUT) {
                ESP_LOGE(TAG, "WiFi认证失败，密码错误，保持配网模式");
                connection_result = -1;  // 标记为失败
                connection_in_progress = false;
                
                // 密码错误时不关闭热点，切换回配网模式但保持热点开启
                current_wifi_mode = WIFI_MODE_CONFIG;
                s_retry_num = 0;
                
                // 重新启动配网模式，但保持APSTA模式
                ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
                
                // 重新启动配网服务器（如果已停止）
                if (config_server == NULL) {
                    start_config_webserver();
                }
                return;
            }
        }
        
        if (current_wifi_mode == WIFI_MODE_CONNECTING && s_retry_num < WIFI_MAXIMUM_RETRY) {
            ESP_LOGI(TAG, "重试连接WiFi (第%d次) - 断开原因: %d", s_retry_num + 1, disconnected_event->reason);
            esp_wifi_connect();
            s_retry_num++;
        } else if (s_retry_num >= WIFI_MAXIMUM_RETRY) {
            ESP_LOGE(TAG, "WiFi连接失败，已重试%d次，断开原因: %d", s_retry_num, disconnected_event->reason);
            s_retry_num = 0;
            
            // 如果正在进行连接过程（配网），标记为失败并保持配网模式
            if (connection_in_progress) {
                // 根据断开原因设置更具体的错误信息
                if (disconnected_event->reason == WIFI_REASON_NO_AP_FOUND) {
                    connection_result = -2;  // 网络未找到
                } else if (disconnected_event->reason == WIFI_REASON_AUTH_FAIL || 
                          disconnected_event->reason == WIFI_REASON_4WAY_HANDSHAKE_TIMEOUT ||
                          disconnected_event->reason == WIFI_REASON_HANDSHAKE_TIMEOUT) {
                    connection_result = -1;  // 密码错误
                } else {
                    connection_result = -3;  // 其他错误
                }
                connection_in_progress = false;
                
                current_wifi_mode = WIFI_MODE_CONFIG;
                // 确保回到APSTA模式进行配网
                ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
                
                // 重新启动配网服务器（如果已停止）
                if (config_server == NULL) {
                    start_config_webserver();
                }
            } else {
                // 自动连接失败，但不立即清除配置，先尝试进入配网模式让用户选择
                ESP_LOGW(TAG, "自动连接失败，进入配网模式（保留现有配置）");
                // 注意：不清除配置，给用户机会重新尝试或修改
                // wifi_clear_config(); // 注释掉自动清除配置
                current_wifi_mode = WIFI_MODE_CONFIG;
                wifi_start_config_mode();
                
                // 记录失败原因，便于调试
                ESP_LOGI(TAG, "WiFi自动连接失败，断开原因: %d，重试次数: %d", 
                        disconnected_event->reason, s_retry_num);
            }
        }
    } else if (event_base == IP_EVENT && event_id == IP_EVENT_STA_GOT_IP) {
        ip_event_got_ip_t* event = (ip_event_got_ip_t*) event_data;
        ESP_LOGI(TAG, "WiFi连接成功，IP地址: " IPSTR, IP2STR(&event->ip_info.ip));
        
        // 保存IP地址到全局变量
        snprintf(connected_ip, sizeof(connected_ip), IPSTR, IP2STR(&event->ip_info.ip));
        
        s_retry_num = 0;
        wifi_connected = true;
        current_wifi_mode = WIFI_MODE_CONNECTED;
        
        // 如果正在进行连接过程，标记为成功
        if (connection_in_progress) {
            connection_result = 1;  // 标记为成功
            connection_in_progress = false;
            
            // 只有配网过程中的连接成功才需要重启设备
            ESP_LOGI(TAG, "WiFi配网成功，IP: %s，将在5秒后重启设备", connected_ip);
        } else {
            // 自动连接成功，不需要重启
            ESP_LOGI(TAG, "WiFi自动连接成功，IP: %s，继续正常运行", connected_ip);
        }
        
        // 停止配网服务器
        stop_config_webserver();
        
        // WiFi连接成功后通知WebSocket客户端启动
        extern void start_websocket_client(void);
        start_websocket_client();
    }
    
    // AP模式事件处理
    else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STACONNECTED) {
        ESP_LOGI(TAG, "设备连接到热点");
    } else if (event_base == WIFI_EVENT && event_id == WIFI_EVENT_AP_STADISCONNECTED) {
        ESP_LOGI(TAG, "设备断开热点连接");
    }
}
// 延迟执行STA连接，避免与WIFI启动过程竞争
static void deferred_sta_connect_task(void *pvParameters)
{
    // 稍微等待系统稳定
    vTaskDelay(300 / portTICK_PERIOD_MS);
    ESP_LOGI(TAG, "延迟任务触发 esp_wifi_connect()");
    esp_wifi_connect();
    vTaskDelete(NULL);
}

//=============================================================================
// WiFi初始化和模式切换功能
//=============================================================================

// WiFi配网初始化（主入口）
void wifi_provisioning_init(void)
{
    ESP_LOGI(TAG, "初始化WiFi配网功能，可用内存: %d bytes", esp_get_free_heap_size());
    
    // 初始化NVS
    esp_err_t ret = nvs_flash_init();
    if (ret == ESP_ERR_NVS_NO_FREE_PAGES || ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
        ESP_ERROR_CHECK(nvs_flash_erase());
        ret = nvs_flash_init();
    }
    ESP_ERROR_CHECK(ret);

    // 初始化网络接口
    ESP_ERROR_CHECK(esp_netif_init());
    ESP_ERROR_CHECK(esp_event_loop_create_default());
    
    // 创建STA和AP网络接口
    esp_netif_create_default_wifi_sta();
    esp_netif_create_default_wifi_ap();
    
    // 初始化WiFi
    wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
    ESP_ERROR_CHECK(esp_wifi_init(&cfg));
    
    // 注册WiFi事件处理器
    esp_event_handler_instance_t instance_any_id;
    esp_event_handler_instance_t instance_got_ip;
    ESP_ERROR_CHECK(esp_event_handler_instance_register(WIFI_EVENT,
                                                        ESP_EVENT_ANY_ID,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_any_id));
    ESP_ERROR_CHECK(esp_event_handler_instance_register(IP_EVENT,
                                                        IP_EVENT_STA_GOT_IP,
                                                        &event_handler,
                                                        NULL,
                                                        &instance_got_ip));
    
    // 检查是否已经配置过WiFi
    if (wifi_is_configured()) {
        char ssid[MAX_SSID_LENGTH];
        char password[MAX_PASS_LENGTH];
        if (wifi_load_config(ssid, password) == ESP_OK) {
            ESP_LOGI(TAG, "发现已保存的WiFi配置，尝试自动连接: %s", ssid);
            // 自动连接时不设置配网状态，避免重启循环
            wifi_connect_sta_auto(ssid, password);
            return;
        }
    }

    // 如果没有配置，进入配网模式
    ESP_LOGI(TAG, "未发现WiFi配置，进入配网模式");
    wifi_start_config_mode();
}

// 启动热点配网模式
void wifi_start_config_mode(void)
{
    ESP_LOGI(TAG, "启动热点配网模式");
    current_wifi_mode = WIFI_MODE_CONFIG;

    // 配置AP模式
    wifi_config_t ap_config = {
        .ap = {
            .ssid = WIFI_AP_SSID,
            .ssid_len = strlen(WIFI_AP_SSID),
            .channel = WIFI_AP_CHANNEL,
            .password = WIFI_AP_PASS,
            .max_connection = WIFI_AP_MAX_CONNECTIONS,
            .authmode = strlen(WIFI_AP_PASS) == 0 ? WIFI_AUTH_OPEN : WIFI_AUTH_WPA2_PSK,
            .pmf_cfg = {
                .required = false,
            },
        },
    };
        
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_APSTA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_AP, &ap_config));
    ESP_ERROR_CHECK(esp_wifi_start());

    ESP_LOGI(TAG, "热点已启动: %s", WIFI_AP_SSID);
    
    // 启动配网Web服务器
    start_config_webserver();
}

// 自动连接到已保存的WiFi网络（启动时使用，不触发重启）
void wifi_connect_sta_auto(const char* ssid, const char* password)
{
    ESP_LOGI(TAG, "自动连接WiFi: %s", ssid);
    current_wifi_mode = WIFI_MODE_CONNECTING;
    s_retry_num = 0;

    // 配置STA模式
    wifi_config_t sta_config = {0};
    strncpy((char*)sta_config.sta.ssid, ssid, sizeof(sta_config.sta.ssid) - 1);
    strncpy((char*)sta_config.sta.password, password, sizeof(sta_config.sta.password) - 1);
    // 放宽阈值，允许更广的AP类型（避免偶发现代路由协商阶段失败）
    sta_config.sta.threshold.authmode = WIFI_AUTH_WPA_WPA2_PSK;
    sta_config.sta.pmf_cfg.capable = true;
    sta_config.sta.pmf_cfg.required = false;
    
    // 添加一些连接优化设置
    sta_config.sta.scan_method = WIFI_ALL_CHANNEL_SCAN; // 重启后环境可变，使用全信道扫描更稳
    sta_config.sta.sort_method = WIFI_CONNECT_AP_BY_SECURITY;
    sta_config.sta.threshold.rssi = -127;  // 接受所有信号强度
    sta_config.sta.bssid_set = false;  // 不指定特定的BSSID
    
    ESP_LOGI(TAG, "自动连接配置WiFi - SSID: %s, 密码长度: %d", ssid, strlen(password));
    
    // 自动连接时使用纯STA模式
    ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
    ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta_config));
    ESP_ERROR_CHECK(esp_wifi_start());
    // 不再显式调用 esp_wifi_connect，统一在 WIFI_EVENT_STA_START 中触发
}

// 连接到指定WiFi网络（配网时使用，连接成功会重启）
void wifi_connect_sta(const char* ssid, const char* password)
{
    ESP_LOGI(TAG, "尝试连接WiFi: %s", ssid);
    current_wifi_mode = WIFI_MODE_CONNECTING;
    s_retry_num = 0;

    // 配置STA模式
    wifi_config_t sta_config = {0};
    strncpy((char*)sta_config.sta.ssid, ssid, sizeof(sta_config.sta.ssid) - 1);
    strncpy((char*)sta_config.sta.password, password, sizeof(sta_config.sta.password) - 1);
    sta_config.sta.threshold.authmode = WIFI_AUTH_WPA2_PSK;
    sta_config.sta.pmf_cfg.capable = true;
    sta_config.sta.pmf_cfg.required = false;
    
    // 添加一些连接优化设置
    sta_config.sta.scan_method = WIFI_ALL_CHANNEL_SCAN;
    sta_config.sta.sort_method = WIFI_CONNECT_AP_BY_SECURITY;
    sta_config.sta.threshold.rssi = -127;  // 接受所有信号强度
    sta_config.sta.bssid_set = false;  // 不指定特定的BSSID
    
    ESP_LOGI(TAG, "配置WiFi - SSID: %s, 密码长度: %d", ssid, strlen(password));
    
    // 在配网过程中保持APSTA模式，以便配网失败时热点仍然可用
    wifi_mode_t current_mode;
    esp_wifi_get_mode(&current_mode);
    if (current_mode == WIFI_MODE_APSTA || current_mode == WIFI_MODE_AP) {
        // 保持APSTA模式，不改变WiFi模式
        ESP_LOGI(TAG, "保持APSTA模式进行连接");
        ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta_config));
        // 在APSTA模式下，直接开始连接
        ESP_ERROR_CHECK(esp_wifi_connect());
    } else {
        ESP_ERROR_CHECK(esp_wifi_set_mode(WIFI_MODE_STA));
        ESP_ERROR_CHECK(esp_wifi_set_config(WIFI_IF_STA, &sta_config));
        ESP_ERROR_CHECK(esp_wifi_start());
        // 不再在此处调用 esp_wifi_connect，避免“sta is connecting”
    }
}

// 保持向后兼容的函数
void wifi_init_sta(void)
{
    wifi_provisioning_init();
}

//=============================================================================
// URL编码/解码相关功能
//=============================================================================

// 将十六进制字符转换为数字
static int hex_to_int(char c)
{
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    return -1;
}

// 改进的URL解码函数，更好地处理UTF-8编码的中文字符
static void url_decode(char* dst, const char* src, size_t max_len)
{
    const char* p = src;
    char* q = dst;
    size_t len = 0;
    
    // 确保有足够的空间存放结果和结束符
    if (max_len == 0) return;
    max_len--; // 为结束符预留空间
    
    while (*p && len < max_len) {
        if (*p == '%' && p[1] && p[2]) {
            int h1 = hex_to_int(p[1]);
            int h2 = hex_to_int(p[2]);
            if (h1 >= 0 && h2 >= 0) {
                unsigned char decoded_byte = (unsigned char)((h1 << 4) | h2);
                *q++ = (char)decoded_byte;
                p += 3;
                len++;
                continue;
            }
        }
        
        if (*p == '+') {
            *q++ = ' ';
        } else {
            *q++ = *p;
        }
        p++;
        len++;
    }
    *q = '\0';
    
    // 验证UTF-8编码的有效性并记录日志
    ESP_LOGD(TAG, "URL解码结果: %s (长度: %d字节)", dst, len);
}

// JSON字符串转义函数
static void json_escape_string(char* dst, const char* src, size_t max_len)
{
    const char* p = src;
    char* q = dst;
    size_t len = 0;
    
    while (*p && len < max_len - 2) { // 保留2个字符用于可能的转义和结束符
        switch (*p) {
            case '"':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = '"'; len += 2;
                }
                break;
            case '\\':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = '\\'; len += 2;
                }
                break;
            case '\b':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = 'b'; len += 2;
                }
                break;
            case '\f':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = 'f'; len += 2;
                }
                break;
            case '\n':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = 'n'; len += 2;
                }
                break;
            case '\r':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = 'r'; len += 2;
                }
                break;
            case '\t':
                if (len < max_len - 3) {
                    *q++ = '\\'; *q++ = 't'; len += 2;
                }
                break;
            default:
                // 对于其他字符，如果是可打印字符或UTF-8字符，保留
                if ((unsigned char)*p >= 0x20 || (unsigned char)*p >= 0x80) {
                    *q++ = *p; len++;
                }
                break;
        }
        p++;
    }
    *q = '\0';
}

//=============================================================================
// 配网Web服务器相关功能
//=============================================================================

// 声明嵌入的HTML文件
extern const char wifi_config_html_start[] asm("_binary_wifi_config_html_start");
extern const char wifi_config_html_end[]   asm("_binary_wifi_config_html_end");

// 配网页面处理
esp_err_t config_page_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "text/html");
    httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
    
    // 使用嵌入的HTML文件
    const size_t html_len = wifi_config_html_end - wifi_config_html_start;
    return httpd_resp_send(req, wifi_config_html_start, html_len);
}

// WiFi扫描API处理
esp_err_t wifi_scan_handler(httpd_req_t *req)
{
    ESP_LOGI(TAG, "收到WiFi扫描请求");
    
    wifi_ap_record_t ap_records[WIFI_SCAN_LIST_SIZE];
    uint16_t ap_count = WIFI_SCAN_LIST_SIZE;
    
    esp_err_t ret = wifi_scan_networks(ap_records, &ap_count);
    
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    
    if (ret != ESP_OK) {
        char error_msg[128];
        snprintf(error_msg, sizeof(error_msg), 
            "{\"success\":false,\"message\":\"扫描失败: %s\"}", esp_err_to_name(ret));
        ESP_LOGE(TAG, "WiFi扫描失败，返回错误: %s", esp_err_to_name(ret));
        httpd_resp_send(req, error_msg, -1);
        return ESP_FAIL;
    }
    
    ESP_LOGI(TAG, "WiFi扫描成功，找到%d个网络", ap_count);
    
    // 动态分配足够的内存
    size_t json_size = 1024 + (ap_count * 150);  // 为每个网络预留150字节
    char *json_response = malloc(json_size);
    if (!json_response) {
        ESP_LOGE(TAG, "分配JSON响应内存失败");
        httpd_resp_send(req, "{\"success\":false,\"message\":\"内存不足\"}", -1);
        return ESP_FAIL;
    }
    
    strcpy(json_response, "{\"success\":true,\"networks\":[");
    
    for (int i = 0; i < ap_count; i++) {
        char network_json[300];  // 增加缓冲区大小以支持转义字符
        // 正确处理SSID中的特殊字符
        char safe_ssid[128];  // 增大缓冲区以容纳转义后的字符串
        
        // 使用完整的JSON转义函数
        json_escape_string(safe_ssid, (char*)ap_records[i].ssid, sizeof(safe_ssid));
        
        snprintf(network_json, sizeof(network_json), 
            "%s{\"ssid\":\"%s\",\"rssi\":%d,\"authmode\":%d}",
            i > 0 ? "," : "",
            safe_ssid,
            ap_records[i].rssi,
            ap_records[i].authmode);
            
        // 检查是否会超出缓冲区
        if (strlen(json_response) + strlen(network_json) + 10 < json_size) {
            strcat(json_response, network_json);
        } else {
            ESP_LOGW(TAG, "JSON响应缓冲区不足，截断到%d个网络", i);
            break;
        }
    }
    
    strcat(json_response, "]}");
    
    ESP_LOGI(TAG, "返回JSON响应，长度: %d", strlen(json_response));
    httpd_resp_send(req, json_response, strlen(json_response));
    free(json_response);
    return ESP_OK;
}

// WiFi连接API处理
esp_err_t wifi_connect_handler(httpd_req_t *req)
{
    char buf[256];
    int ret = httpd_req_recv(req, buf, sizeof(buf) - 1);
    if (ret <= 0) {
        httpd_resp_send(req, "{\"success\":false,\"message\":\"无效请求\"}", -1);
        return ESP_FAIL;
    }
    buf[ret] = '\0';
    
    // 解析POST数据
    char ssid[MAX_SSID_LENGTH] = {0};
    char password[MAX_PASS_LENGTH] = {0};
    
    char *ssid_start = strstr(buf, "ssid=");
    char *pwd_start = strstr(buf, "password=");
    
    if (!ssid_start) {
        httpd_resp_set_type(req, "application/json");
        httpd_resp_send(req, "{\"success\":false,\"message\":\"缺少SSID\"}", -1);
        return ESP_FAIL;
    }
    
    ssid_start += 5; // skip "ssid="
    char *ssid_end = strchr(ssid_start, '&');
    int ssid_len = ssid_end ? (ssid_end - ssid_start) : strlen(ssid_start);
    
    // 临时存储原始编码的SSID
    char encoded_ssid[MAX_SSID_LENGTH];
    if (ssid_len >= MAX_SSID_LENGTH) ssid_len = MAX_SSID_LENGTH - 1;
    strncpy(encoded_ssid, ssid_start, ssid_len);
    encoded_ssid[ssid_len] = '\0';
    
    // 完整URL解码SSID
    url_decode(ssid, encoded_ssid, MAX_SSID_LENGTH);
    
    if (pwd_start) {
        pwd_start += 9; // skip "password="
        char *pwd_end = strchr(pwd_start, '&');
        int pwd_len = pwd_end ? (pwd_end - pwd_start) : strlen(pwd_start);
        
        // 临时存储原始编码的密码
        char encoded_password[MAX_PASS_LENGTH];
        if (pwd_len >= MAX_PASS_LENGTH) pwd_len = MAX_PASS_LENGTH - 1;
        strncpy(encoded_password, pwd_start, pwd_len);
        encoded_password[pwd_len] = '\0';
        
        // 完整URL解码密码
        url_decode(password, encoded_password, MAX_PASS_LENGTH);
    }
    
    ESP_LOGI(TAG, "收到WiFi配置请求: SSID=%s, password=%s", ssid, password);
    
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    
    // 保存配置
    esp_err_t save_ret = wifi_save_config(ssid, password);
    if (save_ret != ESP_OK) {
        httpd_resp_send(req, "{\"success\":false,\"message\":\"保存配置失败\"}", -1);
        return ESP_FAIL;
    }
    
    // 设置连接状态
    connection_in_progress = true;
    connection_result = 0;
    strncpy(connecting_ssid, ssid, MAX_SSID_LENGTH - 1);
    connecting_ssid[MAX_SSID_LENGTH - 1] = '\0';
    
    // 开始连接
    wifi_connect_sta(ssid, password);
    
    // 等待连接结果，最多等待30秒
    int wait_time = 0;
    const int max_wait = 30000; // 30秒
    const int check_interval = 500; // 500ms
    
    while (connection_in_progress && wait_time < max_wait) {
        vTaskDelay(check_interval / portTICK_PERIOD_MS);
        wait_time += check_interval;
        
        // 检查连接结果
        if (connection_result != 0) {
            break;
        }
    }
    
    // 发送最终结果
    if (connection_result == 1) {
        // 连接成功，返回IP地址给前端
        char success_response[256];
        snprintf(success_response, sizeof(success_response), 
            "{\"success\":true,\"message\":\"WiFi连接成功！设备将在5秒后重启\",\"ip\":\"%s\"}", 
            connected_ip);
        httpd_resp_send(req, success_response, -1);
        ESP_LOGI(TAG, "WiFi连接成功响应已发送，IP: %s", connected_ip);
        
        // 创建延迟重启任务
        xTaskCreate(delayed_restart_task, "delayed_restart", 2048, NULL, 1, NULL);
    } else if (connection_result == -1) {
        // 连接失败 - 密码错误
        httpd_resp_send(req, "{\"success\":false,\"message\":\"WiFi密码错误，请重新输入\"}", -1);
        ESP_LOGE(TAG, "WiFi密码错误响应已发送");
    } else if (connection_result == -2) {
        // 连接失败 - 网络未找到
        httpd_resp_send(req, "{\"success\":false,\"message\":\"未找到指定的WiFi网络，请检查网络名称\"}", -1);
        ESP_LOGE(TAG, "WiFi网络未找到响应已发送");
    } else if (connection_result == -3) {
        // 连接失败 - 其他错误
        httpd_resp_send(req, "{\"success\":false,\"message\":\"WiFi连接失败，请检查网络设置和信号强度\"}", -1);
        ESP_LOGE(TAG, "WiFi其他错误响应已发送");
    } else {
        // 超时
        httpd_resp_send(req, "{\"success\":false,\"message\":\"连接超时，请检查WiFi密码和信号强度\"}", -1);
        ESP_LOGW(TAG, "WiFi连接超时响应已发送");
    }
    
    // 重置连接状态
    connection_in_progress = false;
    connection_result = 0;
    
    return ESP_OK;
}

// 配网状态API处理
esp_err_t config_status_handler(httpd_req_t *req)
{
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    
    char status_json[128];
    snprintf(status_json, sizeof(status_json),
        "{\"connected\":%s,\"mode\":\"%s\"}",
        wifi_connected ? "true" : "false",
        current_wifi_mode == WIFI_MODE_CONFIG ? "config" :
        current_wifi_mode == WIFI_MODE_CONNECTING ? "connecting" : "connected");
    
    httpd_resp_send(req, status_json, strlen(status_json));
    return ESP_OK;
}

// 清除WiFi配置API处理
esp_err_t wifi_clear_handler(httpd_req_t *req)
{
    ESP_LOGI(TAG, "收到清除WiFi配置请求");
    
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    
    esp_err_t ret = wifi_clear_config();
    
    if (ret == ESP_OK) {
        httpd_resp_send(req, "{\"success\":true,\"message\":\"WiFi配置已清除\"}", -1);
        ESP_LOGI(TAG, "WiFi配置清除成功");
    } else {
        char error_msg[128];
        snprintf(error_msg, sizeof(error_msg), 
            "{\"success\":false,\"message\":\"清除失败: %s\"}", esp_err_to_name(ret));
        httpd_resp_send(req, error_msg, -1);
        ESP_LOGE(TAG, "WiFi配置清除失败: %s", esp_err_to_name(ret));
    }
    
    return ESP_OK;
}

// 获取当前保存的WiFi配置API处理
esp_err_t wifi_get_config_handler(httpd_req_t *req)
{
    ESP_LOGI(TAG, "收到获取WiFi配置请求");
    
    httpd_resp_set_type(req, "application/json");
    httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
    
    char ssid[MAX_SSID_LENGTH] = {0};
    char password[MAX_PASS_LENGTH] = {0};
    esp_err_t ret = wifi_load_config(ssid, password);
    
    // 增加响应缓冲区大小以避免截断
    char response[512];
    if (ret == ESP_OK && strlen(ssid) > 0) {
        // 只返回SSID，不返回密码（安全考虑）
        char safe_ssid[256];
        json_escape_string(safe_ssid, ssid, sizeof(safe_ssid));
        snprintf(response, sizeof(response), 
            "{\"success\":true,\"configured\":true,\"ssid\":\"%s\"}", safe_ssid);
        ESP_LOGI(TAG, "返回已保存的WiFi配置: %s", ssid);
    } else {
        snprintf(response, sizeof(response), 
            "{\"success\":true,\"configured\":false,\"message\":\"未找到保存的WiFi配置\"}");
        ESP_LOGI(TAG, "未找到保存的WiFi配置");
    }
    
    httpd_resp_send(req, response, strlen(response));
    return ESP_OK;
}

// 启动配网Web服务器
void start_config_webserver(void)
{
    if (config_server != NULL) {
        ESP_LOGW(TAG, "配网Web服务器已在运行");
        return;
    }
    
    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
    config.server_port = 80;
    config.ctrl_port = 32769;
    config.max_open_sockets = 3;
    config.max_uri_handlers = 8;
    config.max_resp_headers = 8;
    config.stack_size = 8192;  // 增加栈大小以解决栈溢出
    config.task_priority = 5;
    config.core_id = 0;
    
    if (httpd_start(&config_server, &config) == ESP_OK) {
        ESP_LOGI(TAG, "配网Web服务器启动成功");
        
        // 注册配网页面
        httpd_uri_t config_page_uri = {
            .uri = "/",
            .method = HTTP_GET,
            .handler = config_page_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &config_page_uri);
        
        // 注册WiFi扫描API
        httpd_uri_t scan_uri = {
            .uri = "/scan",
            .method = HTTP_GET,
            .handler = wifi_scan_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &scan_uri);
        
        // 注册WiFi连接API
        httpd_uri_t connect_uri = {
            .uri = "/connect",
            .method = HTTP_POST,
            .handler = wifi_connect_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &connect_uri);
        
        // 注册状态API
        httpd_uri_t status_uri = {
            .uri = "/status",
            .method = HTTP_GET,
            .handler = config_status_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &status_uri);
        
        // 注册清除配置API
        httpd_uri_t clear_uri = {
            .uri = "/clear",
            .method = HTTP_POST,
            .handler = wifi_clear_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &clear_uri);
        
        // 注册获取配置API
        httpd_uri_t get_config_uri = {
            .uri = "/get_config",
            .method = HTTP_GET,
            .handler = wifi_get_config_handler,
            .user_ctx = NULL
        };
        httpd_register_uri_handler(config_server, &get_config_uri);
        
        ESP_LOGI(TAG, "请连接WiFi热点 '%s' 并访问 http://192.168.4.1 进行配置", WIFI_AP_SSID);
    } else {
        ESP_LOGE(TAG, "配网Web服务器启动失败");
    }
}

// 停止配网Web服务器
void stop_config_webserver(void)
{
    if (config_server != NULL) {
        httpd_stop(config_server);
        config_server = NULL;
        ESP_LOGI(TAG, "配网Web服务器已停止");
    }
}
